package com.aura.springbook.service.impl;

import com.aura.springbook.mapper.UserMapper;
import com.aura.springbook.model.User;
import com.aura.springbook.service.UserService;
import com.aura.springbook.common.util.PasswordUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 用户服务实现类
 * <p>
 * 主要功能：
 * 1. 用户注册（用户名检查、密码加密）
 * 2. 用户登录（密码验证）
 * 3. 用户信息管理（查询、更新）
 * 4. 密码修改
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    private static final Logger logger = LoggerFactory.getLogger(UserServiceImpl.class);

    @Autowired
    private UserMapper userMapper;

    /**
     * 用户注册
     * <p>
     * 注册新用户，检查用户名是否已存在，对密码进行加密存储
     *
     * @param user 用户信息
     * @return 注册成功的用户ID
     * @throws RuntimeException 当用户名已存在时抛出异常
     */
    @Override
    public Long register(User user) {
        logger.debug("开始用户注册, 用户名: {}", user.getUsername());
        
        // 检查用户名是否已存在
        if (isUsernameExists(user.getUsername())) {
            logger.warn("用户注册失败, 用户名已存在: {}", user.getUsername());
            throw new RuntimeException("用户名已存在");
        }

        // 密码加密
        user.setPassword(PasswordUtil.encrypt(user.getPassword()));

        // 保存用户
        userMapper.insert(user);
        logger.info("用户注册成功, 用户ID: {}, 用户名: {}", user.getId(), user.getUsername());
        return user.getId();
    }

    /**
     * 用户登录
     * <p>
     * 验证用户名和密码，返回登录成功的用户信息
     *
     * @param username 用户名
     * @param password 密码
     * @return 登录成功的用户信息，登录失败返回null
     */
    @Override
    public User login(String username, String password) {
        logger.debug("开始用户登录, 用户名: {}", username);
        
        // 根据用户名查询用户
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("username", username);
        User user = userMapper.selectOne(queryWrapper);

        // 验证用户是否存在以及密码是否正确
        if (user != null && PasswordUtil.verify(password, user.getPassword())) {
            logger.info("用户登录成功, 用户ID: {}, 用户名: {}", user.getId(), username);
            return user;
        }

        logger.warn("用户登录失败, 用户名: {}", username);
        return null;
    }

    /**
     * 根据ID查询用户信息
     *
     * @param id 用户ID
     * @return 用户信息
     */
    @Override
    public User getUserById(Long id) {
        logger.debug("开始查询用户信息, 用户ID: {}", id);
        User user = userMapper.selectById(id);
        if (user != null) {
            logger.debug("查询用户信息成功, 用户ID: {}, 用户名: {}", id, user.getUsername());
        } else {
            logger.warn("查询用户信息失败, 用户ID: {} 不存在", id);
        }
        return user;
    }

    /**
     * 更新用户信息
     * <p>
     * 更新用户的个人信息（真实姓名、联系电话等）
     * 只更新非空字段，避免覆盖原有数据
     *
     * @param id   用户ID
     * @param user 更新的用户信息
     * @return 是否更新成功
     */
    @Override
    public boolean updateUserInfo(Long id, User user) {
        logger.debug("开始更新用户信息, 用户ID: {}", id);
        User existingUser = userMapper.selectById(id);
        if (existingUser == null) {
            logger.warn("更新用户信息失败, 用户ID: {} 不存在", id);
            return false;
        }

        // 只更新允许修改的字段
        if (user.getRealName() != null) {
            existingUser.setRealName(user.getRealName());
        }
        if (user.getPhone() != null) {
            existingUser.setPhone(user.getPhone());
        }

        boolean result = userMapper.updateById(existingUser) > 0;
        if (result) {
            logger.debug("更新用户信息成功, 用户ID: {}", id);
        } else {
            logger.warn("更新用户信息失败, 用户ID: {}", id);
        }
        return result;
    }

    /**
     * 检查指定用户名是否已被其他用户使用
     *
     * @param username 用户名
     * @return 是否存在
     */
    @Override
    public boolean isUsernameExists(String username) {
        logger.debug("检查用户名是否存在, 用户名: {}", username);
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("username", username);
        long count = userMapper.selectCount(queryWrapper);
        boolean exists = count > 0;
        logger.debug("用户名{}存在: {}", username, exists);
        return exists;
    }

    /**
     * 修改用户登录密码，新密码不能与旧密码相同
     *
     * @param id          用户ID
     * @param newPassword 新密码
     * @return 是否修改成功，如果新密码与旧密码相同则返回false
     */
    @Override
    public boolean changePassword(Long id, String newPassword) {
        logger.debug("开始修改用户密码, 用户ID: {}", id);
        User user = userMapper.selectById(id);
        if (user == null) {
            logger.warn("修改用户密码失败, 用户ID: {} 不存在", id);
            return false;
        }

        // 验证新密码是否与旧密码相同
        if (PasswordUtil.verify(newPassword, user.getPassword())) {
            logger.warn("修改用户密码失败, 新密码与旧密码相同, 用户ID: {}", id);
            return false; // 新密码与旧密码相同
        }

        // 更新密码
        user.setPassword(PasswordUtil.encrypt(newPassword));
        boolean result = userMapper.updateById(user) > 0;
        if (result) {
            logger.info("修改用户密码成功, 用户ID: {}", id);
        } else {
            logger.warn("修改用户密码失败, 用户ID: {}", id);
        }
        return result;
    }
}